'use strict';
// Copyright 2014 Blueant Inc. All Rights Reserved.

/**
 * @fileoverview 竞技场
 * @author agl
 */

var _ = require('lodash');
var moment = require('moment');
var async = require('async');
var modelUtil = require('../util/modelUtil');
var constantUtil = require('../util/constantUtil');
var Code = require('../consts/code.js');
var mongoConnector = require('../libs/mongodb/mongoConnector');
/* jshint unused:false */
var arenaSchema = require('../schemas/arenaSchema');
var Arena = mongoConnector().model('Arena');
var PlayerManager = require('../libs/playerManager');
var soldierService = require('../services/soldierService.js');

/**
 * 根据角色id获取竞技场数据
 */
module.exports.getByRoleId = function (role_id, cb) {
    modelUtil.getByRoleId(Arena, role_id, function (err, arena_model) {
        if (!!err) {
            console.error(err);
            return cb(err);
        }
        cb(null, arena_model);
    });
};

/**
 * 按条件参数查找
 */
module.exports.findWhere = function (where, cb) {
    Arena.find(where, cb);
};

/**
 * 按排名范围查询玩家列表(不含NPC)
 */
module.exports.findPlayerByRankRange = function (start_rank, end_rank, cb) {
    Arena.find({
        $and: [{
                rank: {
                    $gte: start_rank
                }
            }, {
                rank: {
                    $lte: end_rank
                }
            }, {
                role_id: {
                    $ne: 0
                }
            }, {
                npc_id: 0
            }
    ]
    }, {
        role_id: 1,
        rank: 1
    }).sort({
        rank: 1
    }).exec(cb);
};

/**
 * 查询竞技场前n名玩家
 */
module.exports.findTop = function (count, cb) {
    Arena.find({
        rank: {
            $ne: 0
        }
    }).sort({
        rank: 1
    }).limit(count).exec(cb);
};

/**
 * 查询NPC信息
 */
module.exports.findNpc = function (npc_id, cb) {
    Arena.findOne({
        npc_id: npc_id
    }).exec(cb);
};

/**
 * 按排名取出一组玩家
 */
module.exports.findByRank = function (rank_list, cb) {
    Arena.find({
        rank: {
            $in: rank_list
        }
    }).sort({
        rank: 1
    }).exec(function (err, arena_list) {
        var role_list = [];
        _.forEach(arena_list, function (item) {
            role_list.push({
                role_id: item.role_id,
                npc_id: item.npc_id,
                rank: item.rank,
                def_soldier_list: _.clone(item.def_soldier_list),
                def_power: item.def_power
            });
        });
        cb(null, role_list);
    });
};

/**
 * 5点刷新
 */
module.exports.onFiveRefresh = function (self, callback) {
    self.refreshShop();
    self.remain_fight_times = constantUtil.value('arena_challenge_times');
    self.buy_fight_times = 0;
    self.refresh_shop_times = 0;
    callback();
};

/**
 * 查询下一个排名
 */
module.exports.getNextRank = function (cb) {
    Arena.findOne({})
        .sort({
            rank: -1
        })
        .limit(1)
        .exec(function (err, model) {
            if (!!model) {
                cb(null, model.rank + 1);
            } else {
                cb(null, 1);
            }
        });
};

/**
 * 锁定玩家
 */
module.exports.lockRoles = function (role_id_list, rank_list, cb) {
    var now_tm = moment().unix();
    var role_id = role_id_list[0];
    var timeout_tm = now_tm - 20;

    // 撤销超时的锁定
    Arena.update({
        $or: [{
            locked_role_id: {
                $ne: 0
            },
            locked_time: {
                $lt: timeout_tm
            }
        }, {
            locked_role_id: role_id
        }]
    }, {
        locked_role_id: 0,
        locked_time: 0
    }, {
        multi: true
    }, function (err, numberAffected) {
        if (!!err) {
            return cb(err);
        }

        // 按列表锁定玩家
        Arena.update({
            role_id: {
                $in: role_id_list
            },
            rank: {
                $in: rank_list
            },
            locked_role_id: 0
        }, {
            locked_role_id: role_id,
            locked_time: now_tm
        }, {
            multi: true
        }, function (err, numberAffected) {
            if (!!err) {
                return cb(err);
            }
            if (numberAffected.n < role_id_list.length) {
                // 未锁定列表中的所有玩家，则撤销锁定的行
                Arena.update({
                    locked_role_id: role_id
                }, {
                    locked_role_id: 0,
                    locked_time: 0
                }, {
                    multi: true
                }, function (err, numberAffected) {
                    if (!!err) {
                        return cb(err);
                    }
                    cb(null, Code.ARENA_IN_BATTLE);
                });
            } else {
                // 锁定成功
                cb(null);
            }
        });
    });
};

/**
 * 解锁玩家
 */
module.exports.unLockRoles = function (locked_role_id, cb) {
    Arena.update({
        locked_role_id: locked_role_id
    }, {
        locked_role_id: 0,
        locked_time: 0
    }, {
        multi: true
    }, function (err, numberAffected) {
        if (!!err) {
            return cb(err);
        }
        cb(null);
    });
};

// /**
//  * 创建NPC玩家
//  */
// module.exports.createArenaNpcRole = function (npc, cb) {
//     Arena.create({
//         role_id: npc.id,
//         npc_id: npc.id,
//         rank: npc.id,
//         att_soldier_list: npc.soldier_list,
//         def_soldier_list: npc.soldier_list,
//         att_power: npc.fp,
//         def_power: npc.fp
//     }, cb);
// };

/**
 * 创建一组NPC
 */
module.exports.createNpcList = function (npc_list, cb) {
    console.log('---- create arena NPC ------');
    Arena.create(npc_list, function (err) {
        console.log('---- end of create arena NPC ------');
        cb(err);
    });
};

/**
 * 更新NPC数据
 */
module.exports.updateNpc = function (npc_id, new_values, cb) {
    Arena.update({
        npc_id: npc_id
    }, new_values, cb);
};
